/*
 * 网卡测试工具函数头文件
 * 功能：定义网卡性能、稳定性测试相关的函数和结构体
 * 作者：test_code项目
 */

#ifndef PHY_UTILS_H
#define PHY_UTILS_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <linux/ethtool.h>
#include <linux/sockios.h>
#include <linux/if_packet.h>
#include <pthread.h>
#include <stdint.h>

// 网卡测试相关常量定义
#define PHY_MAX_INTERFACE_NAME  16
#define PHY_MAX_HOST_NAME       256
#define PHY_MAX_BUFFER_SIZE     65536
#define PHY_DEFAULT_TIMEOUT     5000    // 5秒超时
#define PHY_MAX_PACKETS         100000

// 错误代码定义
#define PHY_SUCCESS             0
#define PHY_ERROR_INVALID_PARAM -1
#define PHY_ERROR_INTERFACE     -2
#define PHY_ERROR_NETWORK       -3
#define PHY_ERROR_TIMEOUT       -4
#define PHY_ERROR_PERMISSION    -5
#define PHY_ERROR_MEMORY        -6
#define PHY_ERROR_SYSTEM        -7

// 网络接口状态枚举
typedef enum {
    PHY_LINK_DOWN = 0,
    PHY_LINK_UP = 1,
    PHY_LINK_UNKNOWN = -1
} phy_link_status_t;

// 网络统计信息结构体
typedef struct {
    uint64_t rx_packets;
    uint64_t tx_packets;
    uint64_t rx_bytes;
    uint64_t tx_bytes;
    uint64_t rx_errors;
    uint64_t tx_errors;
    uint64_t rx_dropped;
    uint64_t tx_dropped;
} phy_stats_t;

// 链路测试配置
typedef struct {
    int count;              // 测试次数
    int interval;           // 测试间隔（秒）
} phy_link_test_config_t;

// 链路测试结果
typedef struct {
    char interface[PHY_MAX_INTERFACE_NAME];
    int link_up_count;
    int link_down_count;
    double success_rate;
} phy_link_test_result_t;

// 网络接口信息结构体
typedef struct {
    char name[PHY_MAX_INTERFACE_NAME];
    char mac_address[18];
    char ip_address[16];
    char netmask[16];
    char broadcast[16];
    int mtu;
    int speed;              // Mbps
    int duplex;             // 0=半双工, 1=全双工
    int autoneg;            // 0=禁用, 1=启用
    phy_link_status_t link_status;
    uint64_t rx_packets;
    uint64_t tx_packets;
    uint64_t rx_bytes;
    uint64_t tx_bytes;
    uint64_t rx_errors;
    uint64_t tx_errors;
} phy_interface_info_t;

// 速度测试配置
typedef struct {
    int packet_size;
    int packet_count;
    int test_duration;      // 秒
    int tcp_test;           // 是否进行TCP测试
    int udp_test;           // 是否进行UDP测试
    int concurrent_threads; // 并发线程数
} phy_speed_test_config_t;

// 速度测试结果
typedef struct {
    double tcp_upload_mbps;
    double tcp_download_mbps;
    double udp_upload_mbps;
    double udp_download_mbps;
    uint64_t total_bytes_sent;
    uint64_t total_bytes_received;
    double test_duration;
    int packets_sent;
    int packets_received;
    int packets_lost;
    double packet_loss_rate;
} phy_speed_test_result_t;

// 延迟测试结果
typedef struct {
    double min_latency_ms;
    double max_latency_ms;
    double avg_latency_ms;
    double jitter_ms;
    int packets_sent;
    int packets_received;
    int packets_lost;
    double packet_loss_rate;
} phy_latency_test_result_t;

// 延迟测试配置
typedef struct {
    int count;              // 测试包数量
    int interval_ms;        // 发送间隔（毫秒）
    int packet_size;        // 数据包大小
    int timeout_ms;         // 超时时间（毫秒）
    char target_host[PHY_MAX_HOST_NAME]; // 目标主机
} phy_latency_test_config_t;

// 稳定性测试配置
typedef struct {
    int test_duration;      // 测试持续时间（秒）
    int ping_interval;      // ping间隔（秒）
    int packet_size;        // 数据包大小
    int check_link_status;  // 是否检查链路状态
    int monitor_errors;     // 是否监控错误
} phy_stability_test_config_t;

// 稳定性测试结果
typedef struct {
    double uptime_percentage;
    int link_state_changes;
    uint64_t total_errors;
    uint64_t total_packets;
    double avg_latency_ms;
    double max_latency_ms;
    int consecutive_failures;
    int max_consecutive_failures;
} phy_stability_test_result_t;

// 压力测试配置
typedef struct {
    int test_duration;          // 测试持续时间
    int concurrent_connections; // 并发连接数
    int packet_rate;           // 数据包发送速率
    int packet_size;           // 数据包大小
    int cpu_monitor;           // 是否监控CPU使用率
    int memory_monitor;        // 是否监控内存使用
} phy_stress_test_config_t;

// 压力测试结果
typedef struct {
    double max_throughput_mbps;
    double avg_throughput_mbps;
    double cpu_usage_percent;
    double memory_usage_percent;
    uint64_t total_connections;
    uint64_t failed_connections;
    uint64_t total_bytes_transferred;
    int max_concurrent_connections;
} phy_stress_test_result_t;

// 监控配置
typedef struct {
    int update_interval;    // 更新间隔（秒）
    int show_packets;       // 显示数据包统计
    int show_bytes;         // 显示字节统计
    int show_errors;        // 显示错误统计
    int show_link_status;   // 显示链路状态
} phy_monitor_config_t;

// 监控统计信息
typedef struct {
    time_t timestamp;
    uint64_t rx_packets;
    uint64_t tx_packets;
    uint64_t rx_bytes;
    uint64_t tx_bytes;
    uint64_t rx_errors;
    uint64_t tx_errors;
    uint64_t rx_dropped;
    uint64_t tx_dropped;
    double rx_rate_pps;     // 接收速率（包/秒）
    double tx_rate_pps;     // 发送速率（包/秒）
    double rx_rate_mbps;    // 接收速率（Mbps）
    double tx_rate_mbps;    // 发送速率（Mbps）
    phy_link_status_t link_status;
} phy_monitor_stats_t;

// 基础网络接口操作函数
int phy_interface_exists(const char *interface);
int phy_get_interface_info(const char *interface, phy_interface_info_t *info);
void phy_print_interface_info(const phy_interface_info_t *info);
void phy_show_all_interfaces(void);

// 链路状态检测函数
int phy_check_link_status(const char *interface);
int phy_get_link_speed(const char *interface);
int phy_get_duplex_mode(const char *interface);
int phy_get_autoneg_status(const char *interface);
int phy_set_link_settings(const char *interface, int speed, int duplex, int autoneg);

// 网络统计信息函数
int phy_get_interface_stats(const char *interface, phy_interface_info_t *info);
int phy_reset_interface_stats(const char *interface);

// 速度测试函数
int phy_run_speed_test(const char *interface, const char *target_host, 
                       const phy_speed_test_config_t *config, 
                       phy_speed_test_result_t *result);
void phy_print_speed_test_result(const phy_speed_test_result_t *result);

// 延迟测试函数
int phy_run_latency_test(const char *interface, const char *target_host, 
                         int packet_count, phy_latency_test_result_t *result);
void phy_print_latency_test_result(const phy_latency_test_result_t *result);

// 稳定性测试函数
int phy_run_stability_test(const char *interface, const char *target_host,
                          const phy_stability_test_config_t *config,
                          phy_stability_test_result_t *result);
void phy_print_stability_test_result(const phy_stability_test_result_t *result);

// 压力测试函数
int phy_run_stress_test(const char *interface, const char *target_host,
                       const phy_stress_test_config_t *config,
                       phy_stress_test_result_t *result);
void phy_print_stress_test_result(const phy_stress_test_result_t *result);

// 实时监控函数
int phy_start_monitor(const char *interface, const phy_monitor_config_t *config);
int phy_stop_monitor(const char *interface);
int phy_get_monitor_stats(const char *interface, phy_monitor_stats_t *stats);
void phy_print_monitor_stats(const phy_monitor_stats_t *stats);

// 网络连通性测试函数
int phy_ping_host(const char *interface, const char *target_host, 
                  int packet_size, int timeout_ms, double *latency_ms);
int phy_tcp_connect_test(const char *target_host, int port, int timeout_ms);
int phy_udp_send_test(const char *target_host, int port, 
                      const void *data, size_t data_size, int timeout_ms);

// 带宽测试函数
int phy_tcp_bandwidth_test(const char *target_host, int port, 
                          int data_size, int duration_sec, double *bandwidth_mbps);
int phy_udp_bandwidth_test(const char *target_host, int port,
                          int packet_size, int packet_rate, int duration_sec,
                          double *bandwidth_mbps);

// 工具函数
const char *phy_error_string(int error_code);
double phy_get_time_seconds(void);
void phy_set_verbose_mode(int verbose);
void phy_debug_print(const char *format, ...);
void phy_error_print(const char *format, ...);
void phy_info_print(const char *format, ...);

// 系统资源监控函数
double phy_get_cpu_usage(void);
double phy_get_memory_usage(void);
int phy_get_network_load(const char *interface, double *rx_mbps, double *tx_mbps);

// 网络配置函数
int phy_set_interface_up(const char *interface);
int phy_set_interface_down(const char *interface);
int phy_set_interface_mtu(const char *interface, int mtu);
int phy_get_interface_mtu(const char *interface);

// 高级测试函数
int phy_run_comprehensive_test(const char *interface, const char *target_host);
int phy_generate_test_report(const char *interface, const char *output_file);

#endif // PHY_UTILS_H